{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "import sys\n",
    "from simulator import (\n",
    "    Simulator, string_to_micro, micro_to_time,\n",
    "    BUY, SELL, SHORT, EXCH_INET,\n",
    "    BOOK_DEPTH1_PRICE, ORDER_EVENTS,\n",
    "    )\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from statsmodels.tsa.ar_model import AR\n",
    "\n",
    "\n",
    "class Ave_Lee(object):\n",
    "    def __init__(self, session, date, tickers, start_time, end_time):\n",
    "        self.session = session\n",
    "        self.date = date\n",
    "        self.tickers = tickers\n",
    "        self.ticker1 = self.tickers[0]\n",
    "        self.ticker2 = self.tickers[1]\n",
    "        self.start_time = start_time\n",
    "        self.end_time = end_time\n",
    "        self.interval = string_to_micro(\"1s\")\n",
    "        self.state = 'NULL'\n",
    "        \n",
    "        # variables for BUY or SELL\n",
    "        self.side1 = 0\n",
    "        self.side2 = 0\n",
    "        # variables for order size\n",
    "        self.order_size1 = 100\n",
    "        self.order_size2 = 1\n",
    "        # variables to keep track of total shares bought/sold and the corresponding amount of money\n",
    "        self.buy_shares1 = 0\n",
    "        self.buy_dollars = 0\n",
    "        self.sell_shares1 = 0\n",
    "        self.sell_dollars = 0\n",
    "        self.buy_shares2 = 0\n",
    "        self.sell_shares2 = 0\n",
    "        # minimum increment for an order\n",
    "        self.tick_size = 10000\n",
    "        \n",
    "        # variables to keep track of how many positions we have opened and closed respectively\n",
    "        self.open_longs = 0\n",
    "        self.open_shorts = 0\n",
    "        self.close_longs = 0\n",
    "        self.close_shorts = 0 \n",
    "        self.runs = 0\n",
    "        \n",
    "        # variables used for the fitOU, when to open/close a position and how far we look back\n",
    "        self.dt = 1\n",
    "        self.long_open = 1.25 #1.50 #1.25\n",
    "        self.long_close = 0.40 #0.25 #0.50\n",
    "        self.short_open = 1.25 #1.50 #1.25;\n",
    "        self.short_close = 0.40 #0.50 #0.75\n",
    "        self.training_size = 50\n",
    "        \n",
    "        # start timer/ call the start_callback function\n",
    "        self.session.add_timer(self.start_time, self.start_callback)\n",
    "        \n",
    "        # list to store pnl every time we update it\n",
    "        self.pnl = []\n",
    "        # dictionary to store time, midprices and the returns each timestep\n",
    "        self.results = {'time': []}\n",
    "        for ticker in self.tickers:\n",
    "            self.results[ticker] = []\n",
    "            self.results['return {}'.format(ticker)] = []\n",
    "        \n",
    "        # subscribe to the tickers of interest, and set the first timer\n",
    "        for ticker in self.tickers:\n",
    "            self.session.subscribe_ticker_all_feeds(ticker)\n",
    "    \n",
    "    def start_callback(self, time):\n",
    "        for ticker in self.tickers:\n",
    "            self.session.subscribe_event(ticker, ORDER_EVENTS, self.event_callback)\n",
    "        self.session.add_timer(time, self.timer_callback)\n",
    "        \n",
    "    \n",
    "    def event_callback(self, ticker, event_params):\n",
    "        # call the execution manager whenever we have an execution\n",
    "        self.process_executions(event_params)\n",
    "        \n",
    "    def timer_callback(self, time):\n",
    "        self.runs += 1\n",
    "        self.results['time'].append(micro_to_time(time))\n",
    "        # get the best bid and offer, compute the midmarket\n",
    "        bid1, ask1 = self.session.get_inside_market(self.ticker1)\n",
    "        bid2, ask2 = self.session.get_inside_market(self.ticker2)\n",
    "        # append the midprices\n",
    "        self.results[self.ticker1].append(self.get_midmarket(self.ticker1) / 1000000.0)\n",
    "        self.results[self.ticker2].append(self.get_midmarket(self.ticker2) / 1000000.0)\n",
    "        \n",
    "        # start calculating returns after 1 second\n",
    "        if time > self.start_time + 10**6:\n",
    "            self.results['return {}'.format(self.ticker1)].append(np.float(self.returns(self.results[self.ticker1][-2:])))\n",
    "            self.results['return {}'.format(self.ticker2)].append(np.float(self.returns(self.results[self.ticker2][-2:])))\n",
    "        \n",
    "        # start collecting signals after training_size * 1 second\n",
    "        if time > self.start_time + self.training_size * 10**6:\n",
    "            # collect the last training_size of returns\n",
    "            returns1 = self.results['return {}'.format(self.ticker1)][-self.training_size:]\n",
    "            returns2 = self.results['return {}'.format(self.ticker2)][-self.training_size:]\n",
    "            # regress the returns and fit the residuals, calculate the s-score\n",
    "            residuals, a,b = self.regress(returns1,returns2)\n",
    "            kappa, m, sigma, sigmaeq = self.fitOU(residuals)\n",
    "            s = self.sscore(m, sigmaeq)\n",
    "            # find current net position (=0: neutral, <0: we are short asset 1, >0: we are long asset 1)\n",
    "            pos = self.buy_shares1 - self.sell_shares1            \n",
    "            # feature to check if we have orders at the market before we open a position\n",
    "            orders = self.session.get_all_orders()\n",
    "        \n",
    "            if not orders and b > 0:\n" and kappa > 0 and sigma > 0,
    "                if pos == 0:\n",
    "                    if s < -self.long_open:\n",
    "                        self.side1 = BUY\n",
    "                        self.side2 = SELL\n",
    "                        price1 = ask1['price']# - self.tick_size\n",
    "                        price2 = bid2['price']# + self.tick_size\n",
    "                        # make the portfolio self financing by making sure we sell for as much as we buy\n",
    "                        self.order_size2 = int(b * self.order_size1)\n",
    "                        self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                        self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                        self.open_longs += 1\n",
    "                        print(\"open long\")\n",
    "                    elif s > self.short_open:\n",
    "                        self.side1 = SELL\n",
    "                        self.side2 = BUY\n",
    "                        price1 = bid1['price']# + self.tick_size\n",
    "                        price2 = ask2['price']# - self.tick_size\n",
    "                        # make the portfolio self financing by making sure we buy for as much as we sell\n",
    "                        self.order_size2 = int(b * self.order_size1)\n",
    "                        self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                        self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                        self.open_shorts += 1\n",
    "                        print(\"open short\")\n",
    "                elif pos < 0 and s < self.short_close:\n",
    "                    self.side1 = BUY\n",
    "                    self.side2 = SELL\n",
    "                    price1 = ask1['price']# - self.tick_size\n",
    "                    price2 = bid2['price']# + self.tick_size\n",
    "                    self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                    self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                    self.close_shorts += 1\n",
    "                    print(\"short close\")\n",
    "                elif pos > 0 and s > -self.long_close:\n",
    "                    self.side1 = SELL\n",
    "                    self.side2 = BUY\n",
    "                    price1 = bid1['price']# + self.tick_size\n",
    "                    price2 = ask2['price']# - self.tick_size\n",
    "                    self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                    self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                    self.close_longs += 1\n",
    "                    print(\"long close\")\n",
    "        # update pnl every second to see how it evolves over the day            \n",
    "        pnl = self.get_pnl()\n",
    "        self.pnl.append(pnl / 1000000.0)\n",
    "            \n",
    "        # reset the timer unless we are done \n",
    "        if time < self.end_time:\n",
    "            self.session.add_timer(time + self.interval, self.timer_callback) \n",
    "                \n",
    "            \n",
    "    def process_executions(self, evp):\n",
    "        # make sure that we only update if we have executed any orders\n",
    "        # when we want to add transaction costs we do it in this function\n",
    "        if 'executed_orders' in evp:\n",
    "            time = self.session.current_time()\n",
    "            for ex in evp['executed_orders']:\n",
    "                order = ex['order']\n",
    "                side = order['side']\n",
    "                ticker = order['ticker']\n",
    "                if ticker == self.ticker1:\n",
    "                    if side == 'B':\n",
    "                        self.buy_shares1 += ex['quantity_executed']\n",
    "                        #self.buy_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # buy in midmarker to check if spread is \"eating\" profits\n",
    "                        self.buy_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    else:\n",
    "                        self.sell_shares1 += ex['quantity_executed']\n",
    "                        #self.sell_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # sell in midmarker to check if spread is \"eating\" profits\n",
    "                        self.sell_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    pos = self.buy_shares1 - self.sell_shares1\n",
    "                elif ticker == self.ticker2:\n",
    "                    if side == 'B':\n",
    "                        self.buy_shares2 += ex['quantity_executed']\n",
    "                        #self.buy_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # buy in midmarker to check if spread is \"eating\" profits\n",
    "                        self.buy_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    else:\n",
    "                        self.sell_shares2 += ex['quantity_executed']\n",
    "                        #self.sell_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # sell in midmarker to check if spread is \"eating\" profits\n",
    "                        self.sell_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    pos = self.buy_shares2 - self.sell_shares2        \n",
    "                pnl = self.get_pnl()\n",
    "                print \"{0} {1} {quantity_executed} {price_executed} {liquidity} {2} {3}\".format(time, side, pos, pnl, **ex)\n",
    "                \n",
    "\n",
    "    def get_midmarket(self, ticker):\n",
    "        bid, ask = self.session.get_inside_market(ticker)\n",
    "        return (bid['price'] + ask['price']) / 2.0\n",
    "\n",
    "    def get_pnl(self):\n",
    "        # mark to the midmarket\n",
    "        mid1 = self.get_midmarket(self.ticker1)\n",
    "        mid2 = self.get_midmarket(self.ticker2)\n",
    "        pnl = self.sell_dollars - self.buy_dollars + (self.buy_shares1 - self.sell_shares1) * mid1 + (self.buy_shares2 - self.sell_shares2) * mid2\n",
    "        return pnl\n",
    "    \n",
    "    def regress(self, returns1,returns2):\n",
    "        x = np.asarray(returns1).reshape(-1,1)\n",
    "        y = np.asarray(returns2).reshape(-1,1)\n",
    "        model = LinearRegression()\n",
    "        model.fit(x,y)\n",
    "        a = model.intercept_[0]\n",
    "        b = model.coef_[0,0]\n",
    "        residuals = y-model.predict(x)\n",
    "        return residuals, a,b\n",
    "    \n",
    "    def returns(self, midprices):\n",
    "        log_return = np.diff(np.log(midprices), axis=-1)\n",
    "        return log_return #np.diff(midprices, axis=-1)/midprices[:-1]\n",
    "    \n",
    "    def fitOU(self, residual):\n",
    "        ou = np.cumsum(residual)\n",
    "        model = AR(ou)\n",
    "        fittedmodel = model.fit(maxlag=1, disp=-1)  \n",
    "        a = fittedmodel.params[0]\n",
    "        b = fittedmodel.params[1]\n",
    "        var =  fittedmodel.sigma2\n",
    "        if b > 0.0 and b < np.exp(-2.0/self.training_size):\n",
    "            kappa = -np.log(b) / self.dt    \n",
    "            m = a / (1.0 - np.exp(-kappa * self.dt))\n",
    "            sigma = np.sqrt(var * 2.0 * kappa / (1.0 - np.exp(-2.0 * kappa * self.dt)))\n",
    "            sigmaeq = np.sqrt(var / (1.0 - np.exp(-2.0 * kappa * self.dt)));\n",
    "            return kappa, m, sigma, sigmaeq\n",
    "        else:\n",
    "            return -1.0,0,0,0\n",
    "    \n",
    "    def sscore(self, m, sigmaeq):\n",
    "        if sigmaeq != 0:\n",
    "            return -m/sigmaeq\n",
    "        elif m>0:\n",
    "            return 10000000\n",
    "        else:\n",
    "            return -10000000\n",
    "        \n",
    "    def plot_graph(self, pnl):\n",
    "        pnl_array = np.asarray(pnl)\n",
    "        plt.plot(pnl_array)\n",
    "        plt.title('PnL for {} vs {}'.format(self.ticker1, self.ticker2))\n",
    "        plt.show()\n",
    "    \n",
    "    def end(self):\n",
    "        print(\"Total long opens: \" + str(self.open_longs))\n",
    "        print(\"Total short opens: \" + str(self.open_shorts))\n",
    "        print(\"Total long closes: \" + str(self.close_longs))\n",
    "        print(\"Total short closes: \" + str(self.close_shorts))\n",
    "        print('Runs: ' + str(self.runs))\n",
    "        # plot the pnl\n",
    "        self.plot_graph(self.pnl)\n",
    "        #plt.plot(np.asarray(self.pnl))\n",
    "        #plt.show()\n",
    "        return self.get_pnl()\n",
    "\n",
    "date = \"20170413\"\n",
    "tickers = ['GOOG', 'AAPL']\n",
    "start_time = string_to_micro(\"9:30\")\n",
    "end_time = string_to_micro(\"16:00\")\n",
    "sim = Simulator(Ave_Lee)\n",
    "sim.run(date, tickers, use_om=True, start_time=start_time, end_time=end_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Investigate parameters  \n",
    "* Parameters to check:\n",
    "  * Check large amount of pairs\n",
    "  * Frequency for checking returns  \n",
    "  * Order size\n",
    "  * Check more dates\n",
    "  * Threshholds\n",
    "  * Training size\n",
    "  * Trading hours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tickers = ['MSFT', 'AMZN', 'AAPL', 'GOOG', 'IBM', 'INTC', 'CSCO', 'TSM', 'ORCL', 'NVDA', \n",
    "           'ADBE', 'TXN', 'AVGO', 'CRM', 'QCOM', 'BIDU','MU', 'VMW', 'ITW']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSFT vs AMZN\n",
      "4.99999993826e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AMZN vs AAPL\n",
      "3.04999914152e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAPL vs GOOG\n",
      "-62635000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GOOG vs IBM\n",
      "-610765000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IBM vs INTC\n",
      "4.69999983156e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INTC vs CSCO\n",
      "-1950000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSCO vs TSM\n",
      "4.99999996676e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ORCL vs NVDA\n",
      "1.40000002642e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CSCO vs TSM\n",
      "4.99999996676e+17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAPL vs CSCO\n",
      "-9500000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAPL vs ORCL\n",
      "47895000.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f474b6e4890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 36.3 ms, sys: 54.7 ms, total: 91 ms\n",
      "Wall time: 7min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import sys\n",
    "from simulator import (\n",
    "    Simulator, string_to_micro, micro_to_time,\n",
    "    BUY, SELL, SHORT, EXCH_INET,\n",
    "    BOOK_DEPTH1_PRICE, ORDER_EVENTS,\n",
    "    )\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from statsmodels.tsa.ar_model import AR\n",
    "\n",
    "\n",
    "class Ave_Lee(object):\n",
    "    def __init__(self, session, date, tickers, start_time, end_time):\n",
    "        self.session = session\n",
    "        self.date = date\n",
    "        self.tickers = tickers\n",
    "        self.ticker1 = self.tickers[0]\n",
    "        self.ticker2 = self.tickers[1]\n",
    "        self.start_time = start_time\n",
    "        self.end_time = end_time\n",
    "        self.halt_trading = string_to_micro(\"30m\")\n",
    "        self.interval = string_to_micro(\"20s\")\n",
    "        self.interval_returns = string_to_micro(\"1s\")\n",
    "        self.state = 'NULL'\n",
    "        \n",
    "        # variables for BUY or SELL\n",
    "        self.side1 = 0\n",
    "        self.side2 = 0\n",
    "        \n",
    "        # variables for order size\n",
    "        self.order_size1 = 100\n",
    "        self.order_size2 = 1\n",
    "        \n",
    "        # variables to keep track of total shares bought/sold and the corresponding amount of money\n",
    "        self.buy_shares1 = 0\n",
    "        self.buy_dollars = 0\n",
    "        self.sell_shares1 = 0\n",
    "        self.sell_dollars = 0\n",
    "        self.buy_shares2 = 0\n",
    "        self.sell_shares2 = 0\n",
    "        \n",
    "        # minimum increment for an order\n",
    "        self.tick_size = 10000\n",
    "        \n",
    "        # variables to keep track of how many positions we have opened and closed respectively\n",
    "        self.open_longs = 0\n",
    "        self.open_shorts = 0\n",
    "        self.close_longs = 0\n",
    "        self.close_shorts = 0 \n",
    "        self.runs = 0\n",
    "        \n",
    "        # variables used for the fitOU, when to open/close a position and how far we look back\n",
    "        self.dt = 1\n",
    "        self.long_open = 1.25 #1.50 #1.25\n",
    "        self.long_close = 0.50 #0.25 #0.50\n",
    "        self.short_open = 1.25 #1.50 #1.25;\n",
    "        self.short_close = 0.75 #0.50 #0.75\n",
    "        self.training_size = 200\n",
    "        \n",
    "        # start timer/ call the start_callback function\n",
    "        self.session.add_timer(self.start_time, self.start_callback)\n",
    "        \n",
    "        # list to store pnl every time we update it\n",
    "        self.pnl = []\n",
    "        # dictionary to store time, midprices and the returns each timestep\n",
    "        self.results = {'time': []}\n",
    "        for ticker in self.tickers:\n",
    "            self.results[ticker] = []\n",
    "            self.results['return {}'.format(ticker)] = []\n",
    "        \n",
    "        # subscribe to the tickers of interest, and set the first timer\n",
    "        for ticker in self.tickers:\n",
    "            self.session.subscribe_ticker_all_feeds(ticker)\n",
    "    \n",
    "    \n",
    "    def start_callback(self, time):\n",
    "        for ticker in self.tickers:\n",
    "            self.session.subscribe_event(ticker, ORDER_EVENTS, self.event_callback)\n",
    "        self.session.add_timer(time, self.timer_callback1)\n",
    "        self.session.add_timer(time, self.timer_callback2)\n",
    "        \n",
    "    \n",
    "    def event_callback(self, ticker, event_params):\n",
    "        # call the execution manager whenever we have an execution\n",
    "        self.process_executions(event_params)\n",
    "        \n",
    "        \n",
    "    def timer_callback1(self, time):\n",
    "        # append the midprices\n",
    "        self.results[self.ticker1].append(self.get_midmarket(self.ticker1) / 1000000.0)\n",
    "        self.results[self.ticker2].append(self.get_midmarket(self.ticker2) / 1000000.0)\n",
    "        \n",
    "        # start calculating returns after 1 second\n",
    "        if time > self.start_time + 10**6:\n",
    "            self.results['return {}'.format(self.ticker1)].append(np.float(self.returns(self.results[self.ticker1][-2:])))\n",
    "            self.results['return {}'.format(self.ticker2)].append(np.float(self.returns(self.results[self.ticker2][-2:])))\n",
    "        \n",
    "        # update pnl every second to see how it evolves over the day            \n",
    "        pnl = self.get_pnl()\n",
    "        self.pnl.append(pnl / 1000000.0)\n",
    "        \n",
    "        if time < self.end_time:\n",
    "            self.session.add_timer(time + self.interval_returns, self.timer_callback1)\n",
    "            \n",
    "    \n",
    "    def timer_callback2(self, time):\n",
    "        self.runs += 1\n",
    "        self.results['time'].append(micro_to_time(time))\n",
    "        # get the best bid and offer, compute the midmarket\n",
    "        bid1, ask1 = self.session.get_inside_market(self.ticker1)\n",
    "        bid2, ask2 = self.session.get_inside_market(self.ticker2)\n",
    "        # start collecting signals after training_size * 1 second\n",
    "        if time > self.start_time + self.halt_trading + self.training_size * 10**6:\n",
    "            # collect the last training_size of returns\n",
    "            returns1 = self.results['return {}'.format(self.ticker1)][-self.training_size:]\n",
    "            returns2 = self.results['return {}'.format(self.ticker2)][-self.training_size:]\n",
    "            # regress the returns and fit the residuals, calculate the s-score\n",
    "            residuals, a,b = self.regress(returns1,returns2)\n",
    "            kappa, m, sigma, sigmaeq = self.fitOU(residuals)\n",
    "            s = self.sscore(m, sigmaeq)\n",
    "            # find current net position (=0: neutral, <0: we are short asset 1, >0: we are long asset 1)\n",
    "            pos = self.buy_shares1 - self.sell_shares1            \n",
    "            # feature to check if we have orders at the market before we open a position\n",
    "            orders = self.session.get_all_orders()\n",
    "        \n",
    "            if not orders and b > 0:\n",
    "                if pos == 0:\n",
    "                    if s < -self.long_open:\n",
    "                        self.side1 = BUY\n",
    "                        self.side2 = SELL\n",
    "                        price1 = ask1['price']# - self.tick_size\n",
    "                        price2 = bid2['price']# + self.tick_size\n",
    "                        # make the portfolio self financing by making sure we sell for as much as we buy\n",
    "                        self.order_size2 = int(b * self.order_size1)\n",
    "                        self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                        self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                        self.open_longs += 1                     \n",
    "                    elif s > self.short_open:\n",
    "                        self.side1 = SELL\n",
    "                        self.side2 = BUY\n",
    "                        price1 = bid1['price']# + self.tick_size\n",
    "                        price2 = ask2['price']# - self.tick_size\n",
    "                        # make the portfolio self financing by making sure we buy for as much as we sell\n",
    "                        self.order_size2 = int(b * self.order_size1)\n",
    "                        self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                        self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                        self.open_shorts += 1                    \n",
    "                elif pos < 0 and s < self.short_close:\n",
    "                    self.side1 = BUY\n",
    "                    self.side2 = SELL\n",
    "                    price1 = ask1['price']# - self.tick_size\n",
    "                    price2 = bid2['price']# + self.tick_size\n",
    "                    self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                    self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                    self.close_shorts += 1   \n",
    "                elif pos > 0 and s > -self.long_close:\n",
    "                    self.side1 = SELL\n",
    "                    self.side2 = BUY\n",
    "                    price1 = bid1['price']# + self.tick_size\n",
    "                    price2 = ask2['price']# - self.tick_size\n",
    "                    self.session.add_order(self.ticker1, self.side1, self.order_size1, price1, exchange=EXCH_INET)\n",
    "                    self.session.add_order(self.ticker2, self.side2, self.order_size2, price2, exchange=EXCH_INET)\n",
    "                    self.close_longs += 1          \n",
    "            \n",
    "        # reset the timer unless we are done \n",
    "        if time < self.end_time:\n",
    "            self.session.add_timer(time + self.interval, self.timer_callback2)\n",
    "                \n",
    "            \n",
    "    def process_executions(self, evp):\n",
    "        # make sure that we only update if we have executed any orders\n",
    "        # when we want to add transaction costs we do it in this function\n",
    "        if 'executed_orders' in evp:\n",
    "            time = self.session.current_time()\n",
    "            for ex in evp['executed_orders']:\n",
    "                order = ex['order']\n",
    "                side = order['side']\n",
    "                ticker = order['ticker']\n",
    "                if ticker == self.ticker1:\n",
    "                    if side == 'B':\n",
    "                        self.buy_shares1 += ex['quantity_executed']\n",
    "                        #self.buy_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # buy in midmarker to check if spread is \"eating\" profits\n",
    "                        self.buy_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    else:\n",
    "                        self.sell_shares1 += ex['quantity_executed']\n",
    "                        #self.sell_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # sell in midmarker to check if spread is \"eating\" profits\n",
    "                        self.sell_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    pos = self.buy_shares1 - self.sell_shares1\n",
    "                elif ticker == self.ticker2:\n",
    "                    if side == 'B':\n",
    "                        self.buy_shares2 += ex['quantity_executed']\n",
    "                        #self.buy_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # buy in midmarker to check if spread is \"eating\" profits\n",
    "                        self.buy_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    else:\n",
    "                        self.sell_shares2 += ex['quantity_executed']\n",
    "                        #self.sell_dollars += ex['quantity_executed'] * ex['price_executed']\n",
    "                        # sell in midmarker to check if spread is \"eating\" profits\n",
    "                        self.sell_dollars += ex['quantity_executed'] * self.get_midmarket(ticker)\n",
    "                    pos = self.buy_shares2 - self.sell_shares2        \n",
    "                pnl = self.get_pnl()\n",
    "                #print \"{0} {1} {quantity_executed} {price_executed} {liquidity} {2} {3}\".format(time, side, pos, pnl, **ex)\n",
    "                \n",
    "\n",
    "    def get_midmarket(self, ticker):\n",
    "        bid, ask = self.session.get_inside_market(ticker)\n",
    "        return (bid['price'] + ask['price']) / 2.0\n",
    "    \n",
    "    \n",
    "    def get_pnl(self):\n",
    "        # mark to the midmarket\n",
    "        mid1 = self.get_midmarket(self.ticker1)\n",
    "        mid2 = self.get_midmarket(self.ticker2)\n",
    "        pnl = self.sell_dollars - self.buy_dollars + (self.buy_shares1 - self.sell_shares1) * mid1 + (self.buy_shares2 - self.sell_shares2) * mid2\n",
    "        return pnl\n",
    "    \n",
    "    \n",
    "    def regress(self, returns1,returns2):\n",
    "        x = np.asarray(returns1).reshape(-1,1)\n",
    "        y = np.asarray(returns2).reshape(-1,1)\n",
    "        model = LinearRegression()\n",
    "        model.fit(x,y)\n",
    "        a = model.intercept_[0]\n",
    "        b = model.coef_[0,0]\n",
    "        residuals = y-model.predict(x)\n",
    "        return residuals, a,b\n",
    "    \n",
    "    \n",
    "    def returns(self, midprices):\n",
    "        log_return = np.diff(np.log(midprices), axis=-1)\n",
    "        return log_return #np.diff(midprices, axis=-1)/midprices[:-1]\n",
    "    \n",
    "    \n",
    "    def fitOU(self, residual):\n",
    "        ou = np.cumsum(residual)\n",
    "        model = AR(ou)\n",
    "        fittedmodel = model.fit(maxlag=1, disp=-1)  \n",
    "        a = fittedmodel.params[0]\n",
    "        b = fittedmodel.params[1]\n",
    "        var =  fittedmodel.sigma2\n",
    "        if b > 0.0 and b < np.exp(-2.0/self.training_size):\n",
    "            kappa = -np.log(b) / self.dt    \n",
    "            m = a / (1.0 - np.exp(-kappa * self.dt))\n",
    "            sigma = np.sqrt(var * 2.0 * kappa / (1.0 - np.exp(-2.0 * kappa * self.dt)))\n",
    "            sigmaeq = np.sqrt(var / (1.0 - np.exp(-2.0 * kappa * self.dt)));\n",
    "            return kappa, m, sigma, sigmaeq\n",
    "        else:\n",
    "            return -1.0,0,0,0\n",
    "    \n",
    "    \n",
    "    def sscore(self, m, sigmaeq):\n",
    "        if sigmaeq != 0:\n",
    "            return -m/sigmaeq\n",
    "        elif m>0:\n",
    "            return 10000000\n",
    "        else:\n",
    "            return -10000000\n",
    "        \n",
    "        \n",
    "    def plot_graph(self, pnl):\n",
    "        pnl_array = np.asarray(pnl)\n",
    "        plt.plot(pnl_array)\n",
    "        plt.title('PnL for {} vs {}'.format(self.ticker1, self.ticker2))\n",
    "        #plt.savefig('C3Z/{}_vs_{}.png'.format(self.ticker1, self.ticker2))\n",
    "        plt.show()\n",
    "        return None\n",
    "    \n",
    "    \n",
    "    def end(self):\n",
    "        #print('Time: ' + str(micro_to_time(self.session.current_time())))\n",
    "        print(self.get_pnl())\n",
    "        self.plot_graph(self.pnl)\n",
    "        \n",
    "\n",
    "# generalize the process of simulating the algorithm\n",
    "start_time = string_to_micro(\"9:30\")\n",
    "end_time = string_to_micro(\"16:00\")\n",
    "date = \"20170418\"\n",
    "\n",
    "tickers1 = ['MSFT', 'AMZN', 'AAPL', 'GOOG', 'IBM', 'INTC', 'CSCO', 'ORCL', 'CSCO', 'AAPL', 'AAPL']\n",
    "tickers2 = ['AMZN', 'AAPL', 'GOOG', 'IBM', 'INTC', 'CSCO', 'TSM', 'NVDA', 'TSM', 'CSCO', 'ORCL']\n",
    "\n",
    "for i in range(len(tickers1)):\n",
    "    ticker1 = tickers1[i]\n",
    "    ticker2 = tickers2[i]\n",
    "        \n",
    "    print(str(ticker1) + ' vs ' + str(ticker2))\n",
    "        \n",
    "    sim = Simulator(Ave_Lee)\n",
    "    sim.run(date, [ticker1, ticker2], use_om=True, start_time=start_time, end_time=end_time)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python2",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
